home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / fscache / cacheWrite.doc < prev    next >
Text File  |  1992-12-18  |  4KB  |  84 lines
  1. Fscache_Write(cacheInfoPtr, flags, buffer, offset, lenPtr, remoteWaitPtr)
  2.     firstBlock = (unsigned int) offset / FS_BLOCK_SIZE; 
  3.     lastBlock = (unsigned int) (offset + size - 1) / FS_BLOCK_SIZE;
  4.     for (blockNum = firstBlock; 
  5.      blockNum <= lastBlock; 
  6.      blockNum++, size -= toWrite, buffer += toWrite, offset += toWrite) {
  7. #ifdef lint
  8.     status = Fsdm_BlockAllocate(cacheInfoPtr->hdrPtr,
  9.             offset, toAlloc, dontBlock, &blockAddr, &newBlock);
  10.     status = FsrmtBlockAllocate(cacheInfoPtr->hdrPtr,
  11.             offset, toAlloc, dontBlock, &blockAddr, &newBlock);
  12. #endif /* lint */
  13.         Fscache_FetchBlock(cacheInfoPtr, blockNum, 
  14.          (int)(FSCACHE_IO_IN_PROGRESS | FSCACHE_DATA_BLOCK | dontBlock),
  15.          &blockPtr, &found);
  16.         Vm_CopyIn(toWrite, buffer, blockPtr->blockAddr + 
  17.                 (offset & FS_BLOCK_OFFSET_MASK));
  18.     Fscache_UnlockBlock(blockPtr, (unsigned) modTime, blockAddr,
  19.                 blockSize, FSCACHE_CLEAR_READ_AHEAD);
  20.  
  21. Fsdm_BlockAllocate(hdrPtr, offset, numBytes, flags, blockAddrPtr, newBlockPtr)
  22.     newLastByte = offset + numBytes - 1;
  23.     blockNum = (unsigned int) offset / FS_BLOCK_SIZE;
  24.         status = FragToBlock(handlePtr, curLastBlock, flags);
  25.     status = Fsdm_GetFirstIndex(handlePtr, blockNum, &indexInfo,
  26.                  FSDM_ALLOC_INDIRECT_BLOCKS);
  27.     status = Fsdm_GetNextIndex(handlePtr, &indexInfo, FALSE);
  28.     status = AllocateBlock(handlePtr, descPtr, &indexInfo, newLastByte, 
  29.                curLastBlock, flags, &dirtiedIndex);
  30.     Fsdm_EndIndex(handlePtr, &indexInfo, dirtiedIndex);
  31.     if (newLastByte > descPtr->lastByte) {
  32.     descPtr->lastByte = newLastByte;
  33.     }
  34.     descPtr->flags |= FSDM_FD_DIRTY;
  35.  
  36. AllocateBlock(handlePtr, descPtr, indexInfoPtr, newLastByte, curLastBlock, 
  37.           dontBlock, dirtiedIndexPtr)
  38.     domainPtr = Fsdm_DomainFetch(handlePtr->hdr.fileID.major, FALSE);
  39.         FsdmFragFind(handlePtr->hdr.fileID.minor, domainPtr,
  40.             newFragIndex + 1, -1, -1, -1,
  41.             &blockNum, &newFragOffset);
  42.         *(indexInfoPtr->blockAddrPtr) = 
  43.                 blockNum * FS_FRAGMENTS_PER_BLOCK + newFragOffset;
  44.         FsdmBlockFind(handlePtr->hdr.fileID.minor, domainPtr,
  45.             indexInfoPtr->lastDiskBlock, 
  46.             TRUE, &blockNum, &bitmapPtr);
  47.         *(indexInfoPtr->blockAddrPtr) = 
  48.                         blockNum * FS_FRAGMENTS_PER_BLOCK;
  49.         UpgradeFragment(handlePtr, indexInfoPtr, 
  50.                  curLastBlock, newFragIndex, TRUE,
  51.                  dontBlock, dirtiedIndexPtr);
  52.     Fsdm_DomainRelease(handlePtr->hdr.fileID.major);
  53.  
  54. UpgradeFragment(handlePtr, indexInfoPtr, curLastBlock, newLastFrag, 
  55.         dontWriteThru, dontBlock, dirtiedIndexPtr)
  56.     domainPtr = Fsdm_DomainFetch(handlePtr->hdr.fileID.major, FALSE);
  57.     blockAddr = *(indexInfoPtr->blockAddrPtr);
  58.     curLastFrag = (unsigned int) (descPtr->lastByte & FS_BLOCK_OFFSET_MASK) /
  59.                     FS_FRAGMENT_SIZE;
  60.     curFragBlock = (unsigned int) blockAddr / FS_FRAGMENTS_PER_BLOCK;
  61.     curFragOffset = blockAddr & FRAG_OFFSET_MASK;
  62.     FsdmFragFind(handlePtr->hdr.fileID.minor, domainPtr, newLastFrag + 1, 
  63.             curFragBlock, curFragOffset, curLastFrag + 1,
  64.             &newFragBlock, &newFragOffset);
  65.     FsdmBlockFind(handlePtr->hdr.fileID.minor, domainPtr,
  66.             indexInfoPtr->lastDiskBlock,
  67.             TRUE, &newFragBlock, &bitmapPtr);
  68.     Fscache_FetchBlock(&handlePtr->cacheInfo, 
  69.               curLastBlock, FSCACHE_DATA_BLOCK | dontBlock,
  70.               &fragCacheBlockPtr, &found);
  71.     status = Fsio_DeviceBlockIO(FS_READ, &domainPtr->headerPtr->device,
  72.            blockAddr +
  73.            domainPtr->headerPtr->dataOffset * FS_FRAGMENTS_PER_BLOCK,
  74.            curLastFrag + 1, fragCacheBlockPtr->blockAddr);
  75.     Fscache_UnlockBlock(fragCacheBlockPtr, (unsigned) fsutil_TimeInSeconds, 
  76.                *indexInfoPtr->blockAddrPtr, 
  77.                (newLastFrag + 1) * FS_FRAGMENT_SIZE, flags);
  78.     *(indexInfoPtr->blockAddrPtr) = 
  79.             newFragBlock * FS_FRAGMENTS_PER_BLOCK + newFragOffset;
  80.     descPtr->flags |= FSDM_FD_DIRTY;
  81.     FsdmFragFree(domainPtr, curLastFrag + 1, curFragBlock, curFragOffset);
  82.     Fsdm_DomainRelease(handlePtr->hdr.fileID.major);
  83.  
  84.